// CategoryController.js - 视频类别控制器
const Category = require('../models/Category');

class CategoryController {
  /**
   * 获取所有启用的视频类别（公开接口，无需认证）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async getAllCategories(req, res) {
    try {
      const categories = await Category.getAll();
      res.status(200).json({
        code: 200,
        message: '获取类别列表成功',
        data: categories
      });
    } catch (error) {
      console.error('获取类别列表失败:', error);
      res.status(500).json({
        code: 500,
        message: '获取类别列表失败',
        error: error.message
      });
    }
  }

  /**
   * 根据ID获取类别详情（公开接口，无需认证）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async getCategoryById(req, res) {
    try {
      const { id } = req.params;
      const category = await Category.getById(id);
      
      if (!category) {
        return res.status(404).json({
          code: 404,
          message: '类别不存在'
        });
      }
      
      // 只返回启用的类别给非管理员
      if (category.status !== 1) {
        return res.status(404).json({
          code: 404,
          message: '类别不存在'
        });
      }
      
      res.status(200).json({
        code: 200,
        message: '获取类别成功',
        data: category
      });
    } catch (error) {
      console.error('获取类别失败:', error);
      res.status(500).json({
        code: 500,
        message: '获取类别失败',
        error: error.message
      });
    }
  }

  /**
   * 获取所有类别（包括禁用状态，管理员接口，需认证）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async getAllCategoriesForAdmin(req, res) {
    try {
      const categories = await Category.getAllForAdmin();
      res.status(200).json({
        code: 200,
        message: '获取所有类别成功',
        data: categories
      });
    } catch (error) {
      console.error('获取所有类别失败:', error);
      res.status(500).json({
        code: 500,
        message: '获取所有类别失败',
        error: error.message
      });
    }
  }

  /**
   * 创建新类别（管理员接口，需认证）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async createCategory(req, res) {
    try {
      const { name, alias, icon, description, parentId = null, level = 1, sortOrder = 0 } = req.body;
      
      // 参数验证
      if (!name || !alias) {
        return res.status(400).json({
          code: 400,
          message: '类别名称和别名不能为空'
        });
      }
      
      // 创建类别
      const newCategory = await Category.create(name, alias, icon, description, parentId, level, sortOrder);
      
      res.status(201).json({
        code: 201,
        message: '创建类别成功',
        data: newCategory
      });
    } catch (error) {
      console.error('创建类别失败:', error);
      
      // 处理唯一键冲突
      if (error.code === 'ER_DUP_UNIQUE') {
        return res.status(400).json({
          code: 400,
          message: '类别名称或别名已存在'
        });
      }
      
      res.status(500).json({
        code: 500,
        message: '创建类别失败',
        error: error.message
      });
    }
  }

  /**
   * 更新类别（管理员接口，需认证）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async updateCategory(req, res) {
    try {
      const { id } = req.params;
      const updateData = req.body;
      
      // 验证类别是否存在
      const existingCategory = await Category.getById(id);
      if (!existingCategory) {
        return res.status(404).json({
          code: 404,
          message: '类别不存在'
        });
      }
      
      // 更新类别
      const updatedCategory = await Category.update(id, updateData);
      
      if (!updatedCategory) {
        return res.status(404).json({
          code: 404,
          message: '更新失败，类别不存在'
        });
      }
      
      res.status(200).json({
        code: 200,
        message: '更新类别成功',
        data: updatedCategory
      });
    } catch (error) {
      console.error('更新类别失败:', error);
      
      // 处理唯一键冲突
      if (error.code === 'ER_DUP_UNIQUE') {
        return res.status(400).json({
          code: 400,
          message: '类别名称或别名已存在'
        });
      }
      
      res.status(500).json({
        code: 500,
        message: '更新类别失败',
        error: error.message
      });
    }
  }

  /**
   * 删除类别（管理员接口，需认证）
   * @param {Object} req - 请求对象
   * @param {Object} res - 响应对象
   */
  static async deleteCategory(req, res) {
    try {
      const { id } = req.params;
      
      // 验证类别是否存在
      const existingCategory = await Category.getById(id);
      if (!existingCategory) {
        return res.status(404).json({
          code: 404,
          message: '类别不存在'
        });
      }
      
      // 删除类别（软删除）
      const success = await Category.delete(id);
      
      if (!success) {
        return res.status(404).json({
          code: 404,
          message: '删除失败，类别不存在'
        });
      }
      
      res.status(200).json({
        code: 200,
        message: '删除类别成功'
      });
    } catch (error) {
      console.error('删除类别失败:', error);
      
      // 处理外键约束错误
      if (error.code === 'ER_ROW_IS_REFERENCED_2') {
        return res.status(400).json({
          code: 400,
          message: '该类别下存在子类别或关联数据，无法删除'
        });
      }
      
      res.status(500).json({
        code: 500,
        message: '删除类别失败',
        error: error.message
      });
    }
  }
}

module.exports = CategoryController;